
double-link:     file format elf32-littlearm


Disassembly of section .init:

000103f0 <_init>:
   103f0:	e1a0c00d 	mov	ip, sp
   103f4:	e92ddff0 	push	{r4, r5, r6, r7, r8, r9, sl, fp, ip, lr, pc}
   103f8:	e24cb004 	sub	fp, ip, #4
   103fc:	e91baff0 	ldmdb	fp, {r4, r5, r6, r7, r8, r9, sl, fp, sp, pc}

Disassembly of section .plt:

00010400 <putchar@plt-0x14>:
   10400:	e52de004 	push	{lr}		; (str lr, [sp, #-4]!)
   10404:	e59fe004 	ldr	lr, [pc, #4]	; 10410 <_init+0x20>
   10408:	e08fe00e 	add	lr, pc, lr
   1040c:	e5bef008 	ldr	pc, [lr, #8]!
   10410:	000109f8 	.word	0x000109f8

00010414 <putchar@plt>:
   10414:	e28fc600 	add	ip, pc, #0, 12
   10418:	e28cca10 	add	ip, ip, #16, 20	; 0x10000
   1041c:	e5bcf9f8 	ldr	pc, [ip, #2552]!	; 0x9f8

00010420 <printf@plt>:
   10420:	e28fc600 	add	ip, pc, #0, 12
   10424:	e28cca10 	add	ip, ip, #16, 20	; 0x10000
   10428:	e5bcf9f0 	ldr	pc, [ip, #2544]!	; 0x9f0

0001042c <puts@plt>:
   1042c:	e28fc600 	add	ip, pc, #0, 12
   10430:	e28cca10 	add	ip, ip, #16, 20	; 0x10000
   10434:	e5bcf9e8 	ldr	pc, [ip, #2536]!	; 0x9e8

00010438 <malloc@plt>:
   10438:	e28fc600 	add	ip, pc, #0, 12
   1043c:	e28cca10 	add	ip, ip, #16, 20	; 0x10000
   10440:	e5bcf9e0 	ldr	pc, [ip, #2528]!	; 0x9e0

00010444 <abort@plt>:
   10444:	e28fc600 	add	ip, pc, #0, 12
   10448:	e28cca10 	add	ip, ip, #16, 20	; 0x10000
   1044c:	e5bcf9d8 	ldr	pc, [ip, #2520]!	; 0x9d8

00010450 <__deregister_frame_info@plt>:
   10450:	e28fc600 	add	ip, pc, #0, 12
   10454:	e28cca10 	add	ip, ip, #16, 20	; 0x10000
   10458:	e5bcf9d0 	ldr	pc, [ip, #2512]!	; 0x9d0

0001045c <__uClibc_main@plt>:
   1045c:	e28fc600 	add	ip, pc, #0, 12
   10460:	e28cca10 	add	ip, ip, #16, 20	; 0x10000
   10464:	e5bcf9c8 	ldr	pc, [ip, #2504]!	; 0x9c8

00010468 <scanf@plt>:
   10468:	e28fc600 	add	ip, pc, #0, 12
   1046c:	e28cca10 	add	ip, ip, #16, 20	; 0x10000
   10470:	e5bcf9c0 	ldr	pc, [ip, #2496]!	; 0x9c0

00010474 <exit@plt>:
   10474:	e28fc600 	add	ip, pc, #0, 12
   10478:	e28cca10 	add	ip, ip, #16, 20	; 0x10000
   1047c:	e5bcf9b8 	ldr	pc, [ip, #2488]!	; 0x9b8

00010480 <__register_frame_info@plt>:
   10480:	e28fc600 	add	ip, pc, #0, 12
   10484:	e28cca10 	add	ip, ip, #16, 20	; 0x10000
   10488:	e5bcf9b0 	ldr	pc, [ip, #2480]!	; 0x9b0

0001048c <free@plt>:
   1048c:	e28fc600 	add	ip, pc, #0, 12
   10490:	e28cca10 	add	ip, ip, #16, 20	; 0x10000
   10494:	e5bcf9a8 	ldr	pc, [ip, #2472]!	; 0x9a8

Disassembly of section .text:

00010498 <_start>:
   10498:	e3a0b000 	.word	0xe3a0b000
   1049c:	e3a0e000 	.word	0xe3a0e000
   104a0:	e49d1004 	.word	0xe49d1004
   104a4:	e1a0200d 	.word	0xe1a0200d
   104a8:	e52d2004 	.word	0xe52d2004
   104ac:	e52d0004 	.word	0xe52d0004
   104b0:	e59fc010 	.word	0xe59fc010
   104b4:	e52dc004 	.word	0xe52dc004
   104b8:	e59f000c 	.word	0xe59f000c
   104bc:	e59f300c 	.word	0xe59f300c
   104c0:	eaffffe5 	.word	0xeaffffe5
   104c4:	ebffffde 	.word	0xebffffde
   104c8:	00010be4 	.word	0x00010be4
   104cc:	00010a6c 	.word	0x00010a6c
   104d0:	000103f0 	.word	0x000103f0

000104d4 <deregister_tm_clones>:
   104d4:	e59f301c 	ldr	r3, [pc, #28]	; 104f8 <deregister_tm_clones+0x24>
   104d8:	e59f001c 	ldr	r0, [pc, #28]	; 104fc <deregister_tm_clones+0x28>
   104dc:	e0603003 	rsb	r3, r0, r3
   104e0:	e3530006 	cmp	r3, #6
   104e4:	912fff1e 	bxls	lr
   104e8:	e59f3010 	ldr	r3, [pc, #16]	; 10500 <deregister_tm_clones+0x2c>
   104ec:	e3530000 	cmp	r3, #0
   104f0:	012fff1e 	bxeq	lr
   104f4:	e12fff13 	bx	r3
   104f8:	00020e4b 	.word	0x00020e4b
   104fc:	00020e48 	.word	0x00020e48
   10500:	00000000 	.word	0x00000000

00010504 <register_tm_clones>:
   10504:	e59f1024 	ldr	r1, [pc, #36]	; 10530 <register_tm_clones+0x2c>
   10508:	e59f0024 	ldr	r0, [pc, #36]	; 10534 <register_tm_clones+0x30>
   1050c:	e0601001 	rsb	r1, r0, r1
   10510:	e1a01141 	asr	r1, r1, #2
   10514:	e0811fa1 	add	r1, r1, r1, lsr #31
   10518:	e1b010c1 	asrs	r1, r1, #1
   1051c:	012fff1e 	bxeq	lr
   10520:	e59f3010 	ldr	r3, [pc, #16]	; 10538 <register_tm_clones+0x34>
   10524:	e3530000 	cmp	r3, #0
   10528:	012fff1e 	bxeq	lr
   1052c:	e12fff13 	bx	r3
   10530:	00020e48 	.word	0x00020e48
   10534:	00020e48 	.word	0x00020e48
   10538:	00000000 	.word	0x00000000

0001053c <__do_global_dtors_aux>:
   1053c:	e92d4010 	push	{r4, lr}
   10540:	e59f402c 	ldr	r4, [pc, #44]	; 10574 <__do_global_dtors_aux+0x38>
   10544:	e5d43000 	ldrb	r3, [r4]
   10548:	e3530000 	cmp	r3, #0
   1054c:	18bd8010 	popne	{r4, pc}
   10550:	ebffffdf 	bl	104d4 <deregister_tm_clones>
   10554:	e59f301c 	ldr	r3, [pc, #28]	; 10578 <__do_global_dtors_aux+0x3c>
   10558:	e3530000 	cmp	r3, #0
   1055c:	0a000001 	beq	10568 <__do_global_dtors_aux+0x2c>
   10560:	e59f0014 	ldr	r0, [pc, #20]	; 1057c <__do_global_dtors_aux+0x40>
   10564:	ebffffb9 	bl	10450 <__deregister_frame_info@plt>
   10568:	e3a03001 	mov	r3, #1
   1056c:	e5c43000 	strb	r3, [r4]
   10570:	e8bd8010 	pop	{r4, pc}
   10574:	00020e48 	.word	0x00020e48
   10578:	00000000 	.word	0x00000000
   1057c:	00010d40 	.word	0x00010d40

00010580 <frame_dummy>:
   10580:	e59f3040 	ldr	r3, [pc, #64]	; 105c8 <frame_dummy+0x48>
   10584:	e92d4010 	push	{r4, lr}
   10588:	e3530000 	cmp	r3, #0
   1058c:	0a000002 	beq	1059c <frame_dummy+0x1c>
   10590:	e59f1034 	ldr	r1, [pc, #52]	; 105cc <frame_dummy+0x4c>
   10594:	e59f0034 	ldr	r0, [pc, #52]	; 105d0 <frame_dummy+0x50>
   10598:	ebffffb8 	bl	10480 <__register_frame_info@plt>
   1059c:	e59f0030 	ldr	r0, [pc, #48]	; 105d4 <frame_dummy+0x54>
   105a0:	e5903000 	ldr	r3, [r0]
   105a4:	e3530000 	cmp	r3, #0
   105a8:	1a000001 	bne	105b4 <frame_dummy+0x34>
   105ac:	e8bd4010 	pop	{r4, lr}
   105b0:	eaffffd3 	b	10504 <register_tm_clones>
   105b4:	e59f301c 	ldr	r3, [pc, #28]	; 105d8 <frame_dummy+0x58>
   105b8:	e3530000 	cmp	r3, #0
   105bc:	0afffffa 	beq	105ac <frame_dummy+0x2c>
   105c0:	e12fff33 	blx	r3
   105c4:	eafffff8 	b	105ac <frame_dummy+0x2c>
   105c8:	00000000 	.word	0x00000000
   105cc:	00020e4c 	.word	0x00020e4c
   105d0:	00010d40 	.word	0x00010d40
   105d4:	00020d4c 	.word	0x00020d4c
   105d8:	00000000 	.word	0x00000000

000105dc <init>:
  struct list * prev;  // 对prev的访问，只有删除时用到，插入时用不到
  struct list * next;
};

struct list * init(void)
{
   105dc:	e92d4800 	push	{fp, lr}
   105e0:	e28db004 	add	fp, sp, #4
   105e4:	e24dd008 	sub	sp, sp, #8
  struct list * head;

  head = (struct list *) malloc (sizeof(struct list));
   105e8:	e3a0000c 	mov	r0, #12
   105ec:	ebffff91 	bl	10438 <malloc@plt>
   105f0:	e1a03000 	mov	r3, r0
   105f4:	e50b3008 	str	r3, [fp, #-8]
  if (!head) {
   105f8:	e51b3008 	ldr	r3, [fp, #-8]
   105fc:	e3530000 	cmp	r3, #0
   10600:	1a000003 	bne	10614 <init+0x38>
    printf(" init malloc fail.\n");
   10604:	e59f0018 	ldr	r0, [pc, #24]	; 10624 <init+0x48>
   10608:	ebffff87 	bl	1042c <puts@plt>
    exit(-1);
   1060c:	e3e00000 	mvn	r0, #0
   10610:	ebffff97 	bl	10474 <exit@plt>
  }

  return head;
   10614:	e51b3008 	ldr	r3, [fp, #-8]
}
   10618:	e1a00003 	mov	r0, r3
   1061c:	e24bd004 	sub	sp, fp, #4
   10620:	e8bd8800 	pop	{fp, pc}
   10624:	00010bf4 	.word	0x00010bf4

00010628 <create>:

struct list * create(struct list * head) 
{
   10628:	e92d4800 	push	{fp, lr}
   1062c:	e28db004 	add	fp, sp, #4
   10630:	e24dd018 	sub	sp, sp, #24
   10634:	e50b0018 	str	r0, [fp, #-24]	; 0xffffffe8
  struct list * src, * new;
  int value;

  src = head;		// 指向头结头,头结点一直停在头结点,靠src指针下移.
   10638:	e51b3018 	ldr	r3, [fp, #-24]	; 0xffffffe8
   1063c:	e50b3008 	str	r3, [fp, #-8]
  scanf("%d", & value);
   10640:	e24b3010 	sub	r3, fp, #16
   10644:	e1a01003 	mov	r1, r3
   10648:	e59f0084 	ldr	r0, [pc, #132]	; 106d4 <create+0xac>
   1064c:	ebffff85 	bl	10468 <scanf@plt>
  while (value != 0) {
   10650:	ea000012 	b	106a0 <create+0x78>
    new = (struct list *) malloc (sizeof(struct list));
   10654:	e3a0000c 	mov	r0, #12
   10658:	ebffff76 	bl	10438 <malloc@plt>
   1065c:	e1a03000 	mov	r3, r0
   10660:	e50b300c 	str	r3, [fp, #-12]
    src->next = new;    // 头结点后继指向新节点
   10664:	e51b3008 	ldr	r3, [fp, #-8]
   10668:	e51b200c 	ldr	r2, [fp, #-12]
   1066c:	e5832008 	str	r2, [r3, #8]
    new->prev = src;    // 新结点前驱指向头结点
   10670:	e51b300c 	ldr	r3, [fp, #-12]
   10674:	e51b2008 	ldr	r2, [fp, #-8]
   10678:	e5832004 	str	r2, [r3, #4]
    new->num = value;
   1067c:	e51b2010 	ldr	r2, [fp, #-16]
   10680:	e51b300c 	ldr	r3, [fp, #-12]
   10684:	e5832000 	str	r2, [r3]
    src = new;          // 头结点指向新结点.即头移到下一个结点.
   10688:	e51b300c 	ldr	r3, [fp, #-12]
   1068c:	e50b3008 	str	r3, [fp, #-8]
    scanf("%d", & value);
   10690:	e24b3010 	sub	r3, fp, #16
   10694:	e1a01003 	mov	r1, r3
   10698:	e59f0034 	ldr	r0, [pc, #52]	; 106d4 <create+0xac>
   1069c:	ebffff71 	bl	10468 <scanf@plt>
  struct list * src, * new;
  int value;

  src = head;		// 指向头结头,头结点一直停在头结点,靠src指针下移.
  scanf("%d", & value);
  while (value != 0) {
   106a0:	e51b3010 	ldr	r3, [fp, #-16]
   106a4:	e3530000 	cmp	r3, #0
   106a8:	1affffe9 	bne	10654 <create+0x2c>
    new->num = value;
    src = new;          // 头结点指向新结点.即头移到下一个结点.
    scanf("%d", & value);
  }

  head->prev = src;     // 头结点前驱指向最后一个结点.
   106ac:	e51b3018 	ldr	r3, [fp, #-24]	; 0xffffffe8
   106b0:	e51b2008 	ldr	r2, [fp, #-8]
   106b4:	e5832004 	str	r2, [r3, #4]
  src->next = head;     // 最后结点后驱指向头结点
   106b8:	e51b3008 	ldr	r3, [fp, #-8]
   106bc:	e51b2018 	ldr	r2, [fp, #-24]	; 0xffffffe8
   106c0:	e5832008 	str	r2, [r3, #8]

  return head;
   106c4:	e51b3018 	ldr	r3, [fp, #-24]	; 0xffffffe8
}
   106c8:	e1a00003 	mov	r0, r3
   106cc:	e24bd004 	sub	sp, fp, #4
   106d0:	e8bd8800 	pop	{fp, pc}
   106d4:	00010c08 	.word	0x00010c08

000106d8 <display>:

void display(struct list * head)
{
   106d8:	e92d4800 	push	{fp, lr}
   106dc:	e28db004 	add	fp, sp, #4
   106e0:	e24dd010 	sub	sp, sp, #16
   106e4:	e50b0010 	str	r0, [fp, #-16]
  struct list * src;

  printf("since head print:\n");
   106e8:	e59f00a8 	ldr	r0, [pc, #168]	; 10798 <display+0xc0>
   106ec:	ebffff4e 	bl	1042c <puts@plt>
  src = head;
   106f0:	e51b3010 	ldr	r3, [fp, #-16]
   106f4:	e50b3008 	str	r3, [fp, #-8]
  src = src->next;
   106f8:	e51b3008 	ldr	r3, [fp, #-8]
   106fc:	e5933008 	ldr	r3, [r3, #8]
   10700:	e50b3008 	str	r3, [fp, #-8]
  do {
    printf(" %d ", src->num);
   10704:	e51b3008 	ldr	r3, [fp, #-8]
   10708:	e5933000 	ldr	r3, [r3]
   1070c:	e1a01003 	mov	r1, r3
   10710:	e59f0084 	ldr	r0, [pc, #132]	; 1079c <display+0xc4>
   10714:	ebffff41 	bl	10420 <printf@plt>
    src = src->next;
   10718:	e51b3008 	ldr	r3, [fp, #-8]
   1071c:	e5933008 	ldr	r3, [r3, #8]
   10720:	e50b3008 	str	r3, [fp, #-8]
  } while (src != head); // 以头结点结束
   10724:	e51b2008 	ldr	r2, [fp, #-8]
   10728:	e51b3010 	ldr	r3, [fp, #-16]
   1072c:	e1520003 	cmp	r2, r3
   10730:	1afffff3 	bne	10704 <display+0x2c>

  printf("\n");
   10734:	e3a0000a 	mov	r0, #10
   10738:	ebffff35 	bl	10414 <putchar@plt>

  printf("since rear print:\n");
   1073c:	e59f005c 	ldr	r0, [pc, #92]	; 107a0 <display+0xc8>
   10740:	ebffff39 	bl	1042c <puts@plt>
  src = head;
   10744:	e51b3010 	ldr	r3, [fp, #-16]
   10748:	e50b3008 	str	r3, [fp, #-8]
  src = src->prev;
   1074c:	e51b3008 	ldr	r3, [fp, #-8]
   10750:	e5933004 	ldr	r3, [r3, #4]
   10754:	e50b3008 	str	r3, [fp, #-8]
  do {
    printf(" %d ", src->num);
   10758:	e51b3008 	ldr	r3, [fp, #-8]
   1075c:	e5933000 	ldr	r3, [r3]
   10760:	e1a01003 	mov	r1, r3
   10764:	e59f0030 	ldr	r0, [pc, #48]	; 1079c <display+0xc4>
   10768:	ebffff2c 	bl	10420 <printf@plt>
    src = src->prev;
   1076c:	e51b3008 	ldr	r3, [fp, #-8]
   10770:	e5933004 	ldr	r3, [r3, #4]
   10774:	e50b3008 	str	r3, [fp, #-8]
  } while (src != head);
   10778:	e51b2008 	ldr	r2, [fp, #-8]
   1077c:	e51b3010 	ldr	r3, [fp, #-16]
   10780:	e1520003 	cmp	r2, r3
   10784:	1afffff3 	bne	10758 <display+0x80>

  printf("\n");
   10788:	e3a0000a 	mov	r0, #10
   1078c:	ebffff20 	bl	10414 <putchar@plt>
}
   10790:	e24bd004 	sub	sp, fp, #4
   10794:	e8bd8800 	pop	{fp, pc}
   10798:	00010c0c 	.word	0x00010c0c
   1079c:	00010c20 	.word	0x00010c20
   107a0:	00010c28 	.word	0x00010c28

000107a4 <find>:

struct list * find(struct list * head, int position)
{
   107a4:	e52db004 	push	{fp}		; (str fp, [sp, #-4]!)
   107a8:	e28db000 	add	fp, sp, #0
   107ac:	e24dd014 	sub	sp, sp, #20
   107b0:	e50b0010 	str	r0, [fp, #-16]
   107b4:	e50b1014 	str	r1, [fp, #-20]	; 0xffffffec
  struct list * src;
  int pos = 0;
   107b8:	e3a03000 	mov	r3, #0
   107bc:	e50b300c 	str	r3, [fp, #-12]

  src = head;
   107c0:	e51b3010 	ldr	r3, [fp, #-16]
   107c4:	e50b3008 	str	r3, [fp, #-8]
  while ((src->next != head) && (pos < position)) {
   107c8:	ea000005 	b	107e4 <find+0x40>
    src = src->next;
   107cc:	e51b3008 	ldr	r3, [fp, #-8]
   107d0:	e5933008 	ldr	r3, [r3, #8]
   107d4:	e50b3008 	str	r3, [fp, #-8]
    pos++;
   107d8:	e51b300c 	ldr	r3, [fp, #-12]
   107dc:	e2833001 	add	r3, r3, #1
   107e0:	e50b300c 	str	r3, [fp, #-12]
{
  struct list * src;
  int pos = 0;

  src = head;
  while ((src->next != head) && (pos < position)) {
   107e4:	e51b3008 	ldr	r3, [fp, #-8]
   107e8:	e5932008 	ldr	r2, [r3, #8]
   107ec:	e51b3010 	ldr	r3, [fp, #-16]
   107f0:	e1520003 	cmp	r2, r3
   107f4:	0a000003 	beq	10808 <find+0x64>
   107f8:	e51b200c 	ldr	r2, [fp, #-12]
   107fc:	e51b3014 	ldr	r3, [fp, #-20]	; 0xffffffec
   10800:	e1520003 	cmp	r2, r3
   10804:	bafffff0 	blt	107cc <find+0x28>
    src = src->next;
    pos++;
  }
  
  if (position == pos) 
   10808:	e51b2014 	ldr	r2, [fp, #-20]	; 0xffffffec
   1080c:	e51b300c 	ldr	r3, [fp, #-12]
   10810:	e1520003 	cmp	r2, r3
   10814:	1a000001 	bne	10820 <find+0x7c>
    return src;
   10818:	e51b3008 	ldr	r3, [fp, #-8]
   1081c:	ea000000 	b	10824 <find+0x80>
  else
    return NULL;
   10820:	e3a03000 	mov	r3, #0
}
   10824:	e1a00003 	mov	r0, r3
   10828:	e24bd000 	sub	sp, fp, #0
   1082c:	e49db004 	pop	{fp}		; (ldr fp, [sp], #4)
   10830:	e12fff1e 	bx	lr

00010834 <location>:

int location(struct list * head, int value)
{
   10834:	e52db004 	push	{fp}		; (str fp, [sp, #-4]!)
   10838:	e28db000 	add	fp, sp, #0
   1083c:	e24dd014 	sub	sp, sp, #20
   10840:	e50b0010 	str	r0, [fp, #-16]
   10844:	e50b1014 	str	r1, [fp, #-20]	; 0xffffffec
  struct list * src;
  int pos = 0;
   10848:	e3a03000 	mov	r3, #0
   1084c:	e50b300c 	str	r3, [fp, #-12]
  
  src = head;
   10850:	e51b3010 	ldr	r3, [fp, #-16]
   10854:	e50b3008 	str	r3, [fp, #-8]
  while ((src->next != head) && (src->num != value)) {
   10858:	ea000005 	b	10874 <location+0x40>
    src = src->next;
   1085c:	e51b3008 	ldr	r3, [fp, #-8]
   10860:	e5933008 	ldr	r3, [r3, #8]
   10864:	e50b3008 	str	r3, [fp, #-8]
    pos++;
   10868:	e51b300c 	ldr	r3, [fp, #-12]
   1086c:	e2833001 	add	r3, r3, #1
   10870:	e50b300c 	str	r3, [fp, #-12]
{
  struct list * src;
  int pos = 0;
  
  src = head;
  while ((src->next != head) && (src->num != value)) {
   10874:	e51b3008 	ldr	r3, [fp, #-8]
   10878:	e5932008 	ldr	r2, [r3, #8]
   1087c:	e51b3010 	ldr	r3, [fp, #-16]
   10880:	e1520003 	cmp	r2, r3
   10884:	0a000004 	beq	1089c <location+0x68>
   10888:	e51b3008 	ldr	r3, [fp, #-8]
   1088c:	e5932000 	ldr	r2, [r3]
   10890:	e51b3014 	ldr	r3, [fp, #-20]	; 0xffffffec
   10894:	e1520003 	cmp	r2, r3
   10898:	1affffef 	bne	1085c <location+0x28>
    src = src->next;
    pos++;
  }

  if (src->num == value)
   1089c:	e51b3008 	ldr	r3, [fp, #-8]
   108a0:	e5932000 	ldr	r2, [r3]
   108a4:	e51b3014 	ldr	r3, [fp, #-20]	; 0xffffffec
   108a8:	e1520003 	cmp	r2, r3
   108ac:	1a000001 	bne	108b8 <location+0x84>
    return pos;
   108b0:	e51b300c 	ldr	r3, [fp, #-12]
   108b4:	ea000000 	b	108bc <location+0x88>
  else
    return 0;
   108b8:	e3a03000 	mov	r3, #0
}
   108bc:	e1a00003 	mov	r0, r3
   108c0:	e24bd000 	sub	sp, fp, #0
   108c4:	e49db004 	pop	{fp}		; (ldr fp, [sp], #4)
   108c8:	e12fff1e 	bx	lr

000108cc <insert>:

struct list * insert(struct list * head, int position, int value)
{
   108cc:	e92d4800 	push	{fp, lr}
   108d0:	e28db004 	add	fp, sp, #4
   108d4:	e24dd018 	sub	sp, sp, #24
   108d8:	e50b0010 	str	r0, [fp, #-16]
   108dc:	e50b1014 	str	r1, [fp, #-20]	; 0xffffffec
   108e0:	e50b2018 	str	r2, [fp, #-24]	; 0xffffffe8
  struct list * src, * des;

  src = find(head, position - 1);
   108e4:	e51b3014 	ldr	r3, [fp, #-20]	; 0xffffffec
   108e8:	e2433001 	sub	r3, r3, #1
   108ec:	e1a01003 	mov	r1, r3
   108f0:	e51b0010 	ldr	r0, [fp, #-16]
   108f4:	ebffffaa 	bl	107a4 <find>
   108f8:	e50b0008 	str	r0, [fp, #-8]
  if (!src) {
   108fc:	e51b3008 	ldr	r3, [fp, #-8]
   10900:	e3530000 	cmp	r3, #0
   10904:	1a000003 	bne	10918 <insert+0x4c>
    printf("position is not existence.\n");
   10908:	e59f006c 	ldr	r0, [pc, #108]	; 1097c <insert+0xb0>
   1090c:	ebfffec6 	bl	1042c <puts@plt>
    return NULL;
   10910:	e3a03000 	mov	r3, #0
   10914:	ea000015 	b	10970 <insert+0xa4>
  }
  else {
    des = (struct list *) malloc (sizeof(struct list));
   10918:	e3a0000c 	mov	r0, #12
   1091c:	ebfffec5 	bl	10438 <malloc@plt>
   10920:	e1a03000 	mov	r3, r0
   10924:	e50b300c 	str	r3, [fp, #-12]
    des->num = value;
   10928:	e51b300c 	ldr	r3, [fp, #-12]
   1092c:	e51b2018 	ldr	r2, [fp, #-24]	; 0xffffffe8
   10930:	e5832000 	str	r2, [r3]
    des->prev = src;        // 新结点前驱指向前结点.
   10934:	e51b300c 	ldr	r3, [fp, #-12]
   10938:	e51b2008 	ldr	r2, [fp, #-8]
   1093c:	e5832004 	str	r2, [r3, #4]
    des->next = src->next;  // 新结点后驱指向下一个结点.
   10940:	e51b3008 	ldr	r3, [fp, #-8]
   10944:	e5932008 	ldr	r2, [r3, #8]
   10948:	e51b300c 	ldr	r3, [fp, #-12]
   1094c:	e5832008 	str	r2, [r3, #8]
    src->next->prev = des;  // 下一个结点的前驱指向新结点.
   10950:	e51b3008 	ldr	r3, [fp, #-8]
   10954:	e5933008 	ldr	r3, [r3, #8]
   10958:	e51b200c 	ldr	r2, [fp, #-12]
   1095c:	e5832004 	str	r2, [r3, #4]
    src->next = des;        // 原先的src->next指向新结点.即新结点插入.
   10960:	e51b3008 	ldr	r3, [fp, #-8]
   10964:	e51b200c 	ldr	r2, [fp, #-12]
   10968:	e5832008 	str	r2, [r3, #8]
  }

  return head;
   1096c:	e51b3010 	ldr	r3, [fp, #-16]
}
   10970:	e1a00003 	mov	r0, r3
   10974:	e24bd004 	sub	sp, fp, #4
   10978:	e8bd8800 	pop	{fp, pc}
   1097c:	00010c3c 	.word	0x00010c3c

00010980 <delete>:

struct list * delete(struct list * head, int position)
{
   10980:	e92d4800 	push	{fp, lr}
   10984:	e28db004 	add	fp, sp, #4
   10988:	e24dd010 	sub	sp, sp, #16
   1098c:	e50b0010 	str	r0, [fp, #-16]
   10990:	e50b1014 	str	r1, [fp, #-20]	; 0xffffffec
  struct list * src;

  src = find(head, position);
   10994:	e51b1014 	ldr	r1, [fp, #-20]	; 0xffffffec
   10998:	e51b0010 	ldr	r0, [fp, #-16]
   1099c:	ebffff80 	bl	107a4 <find>
   109a0:	e50b0008 	str	r0, [fp, #-8]
  if ((src != NULL) && (src->next != NULL)) {
   109a4:	e51b3008 	ldr	r3, [fp, #-8]
   109a8:	e3530000 	cmp	r3, #0
   109ac:	0a000011 	beq	109f8 <delete+0x78>
   109b0:	e51b3008 	ldr	r3, [fp, #-8]
   109b4:	e5933008 	ldr	r3, [r3, #8]
   109b8:	e3530000 	cmp	r3, #0
   109bc:	0a00000d 	beq	109f8 <delete+0x78>
    src->prev->next = src->next;  // 要删除结点的前结点后驱指向要删除结点的下结点.即前结点向后指.
   109c0:	e51b3008 	ldr	r3, [fp, #-8]
   109c4:	e5933004 	ldr	r3, [r3, #4]
   109c8:	e51b2008 	ldr	r2, [fp, #-8]
   109cc:	e5922008 	ldr	r2, [r2, #8]
   109d0:	e5832008 	str	r2, [r3, #8]
    src->next->prev = src->prev;  // 要删除结点的后结点前驱指向要删除结点的上结点.即后结点向前指.
   109d4:	e51b3008 	ldr	r3, [fp, #-8]
   109d8:	e5933008 	ldr	r3, [r3, #8]
   109dc:	e51b2008 	ldr	r2, [fp, #-8]
   109e0:	e5922004 	ldr	r2, [r2, #4]
   109e4:	e5832004 	str	r2, [r3, #4]
    free(src);
   109e8:	e51b0008 	ldr	r0, [fp, #-8]
   109ec:	ebfffea6 	bl	1048c <free@plt>
  }
  else 
    return NULL;

  return head;
   109f0:	e51b3010 	ldr	r3, [fp, #-16]
   109f4:	ea000000 	b	109fc <delete+0x7c>
    src->prev->next = src->next;  // 要删除结点的前结点后驱指向要删除结点的下结点.即前结点向后指.
    src->next->prev = src->prev;  // 要删除结点的后结点前驱指向要删除结点的上结点.即后结点向前指.
    free(src);
  }
  else 
    return NULL;
   109f8:	e3a03000 	mov	r3, #0

  return head;
}
   109fc:	e1a00003 	mov	r0, r3
   10a00:	e24bd004 	sub	sp, fp, #4
   10a04:	e8bd8800 	pop	{fp, pc}

00010a08 <length>:


int length(struct list * head)
{
   10a08:	e52db004 	push	{fp}		; (str fp, [sp, #-4]!)
   10a0c:	e28db000 	add	fp, sp, #0
   10a10:	e24dd014 	sub	sp, sp, #20
   10a14:	e50b0010 	str	r0, [fp, #-16]
  struct list * src;
  int pos = 0;
   10a18:	e3a03000 	mov	r3, #0
   10a1c:	e50b300c 	str	r3, [fp, #-12]

  src = head;
   10a20:	e51b3010 	ldr	r3, [fp, #-16]
   10a24:	e50b3008 	str	r3, [fp, #-8]
  while (src->next != head) {
   10a28:	ea000005 	b	10a44 <length+0x3c>
    src = src->next;
   10a2c:	e51b3008 	ldr	r3, [fp, #-8]
   10a30:	e5933008 	ldr	r3, [r3, #8]
   10a34:	e50b3008 	str	r3, [fp, #-8]
    pos++;
   10a38:	e51b300c 	ldr	r3, [fp, #-12]
   10a3c:	e2833001 	add	r3, r3, #1
   10a40:	e50b300c 	str	r3, [fp, #-12]
{
  struct list * src;
  int pos = 0;

  src = head;
  while (src->next != head) {
   10a44:	e51b3008 	ldr	r3, [fp, #-8]
   10a48:	e5932008 	ldr	r2, [r3, #8]
   10a4c:	e51b3010 	ldr	r3, [fp, #-16]
   10a50:	e1520003 	cmp	r2, r3
   10a54:	1afffff4 	bne	10a2c <length+0x24>
    src = src->next;
    pos++;
  }

  return pos;
   10a58:	e51b300c 	ldr	r3, [fp, #-12]
}
   10a5c:	e1a00003 	mov	r0, r3
   10a60:	e24bd000 	sub	sp, fp, #0
   10a64:	e49db004 	pop	{fp}		; (ldr fp, [sp], #4)
   10a68:	e12fff1e 	bx	lr

00010a6c <main>:

int main()
{
   10a6c:	e92d4800 	push	{fp, lr}
   10a70:	e28db004 	add	fp, sp, #4
   10a74:	e24dd018 	sub	sp, sp, #24
  struct list * head, * src;
  int input, count;

  head = init();
   10a78:	ebfffed7 	bl	105dc <init>
   10a7c:	e50b0008 	str	r0, [fp, #-8]

  printf("input number, zero exit:\n");
   10a80:	e59f0138 	ldr	r0, [pc, #312]	; 10bc0 <main+0x154>
   10a84:	ebfffe68 	bl	1042c <puts@plt>
  head = create(head);
   10a88:	e51b0008 	ldr	r0, [fp, #-8]
   10a8c:	ebfffee5 	bl	10628 <create>
   10a90:	e50b0008 	str	r0, [fp, #-8]
  display(head);
   10a94:	e51b0008 	ldr	r0, [fp, #-8]
   10a98:	ebffff0e 	bl	106d8 <display>

  printf("input find number:\n");
   10a9c:	e59f0120 	ldr	r0, [pc, #288]	; 10bc4 <main+0x158>
   10aa0:	ebfffe61 	bl	1042c <puts@plt>
  scanf("%d", & count);
   10aa4:	e24b3014 	sub	r3, fp, #20
   10aa8:	e1a01003 	mov	r1, r3
   10aac:	e59f0114 	ldr	r0, [pc, #276]	; 10bc8 <main+0x15c>
   10ab0:	ebfffe6c 	bl	10468 <scanf@plt>
  src = find(head, count);
   10ab4:	e51b3014 	ldr	r3, [fp, #-20]	; 0xffffffec
   10ab8:	e1a01003 	mov	r1, r3
   10abc:	e51b0008 	ldr	r0, [fp, #-8]
   10ac0:	ebffff37 	bl	107a4 <find>
   10ac4:	e50b000c 	str	r0, [fp, #-12]
  printf("The number %d of value is %d\n", count, * src);
   10ac8:	e51b1014 	ldr	r1, [fp, #-20]	; 0xffffffec
   10acc:	e51b300c 	ldr	r3, [fp, #-12]
   10ad0:	e5932008 	ldr	r2, [r3, #8]
   10ad4:	e58d2000 	str	r2, [sp]
   10ad8:	e893000c 	ldm	r3, {r2, r3}
   10adc:	e59f00e8 	ldr	r0, [pc, #232]	; 10bcc <main+0x160>
   10ae0:	ebfffe4e 	bl	10420 <printf@plt>

  printf("input find number:");
   10ae4:	e59f00d8 	ldr	r0, [pc, #216]	; 10bc4 <main+0x158>
   10ae8:	ebfffe4c 	bl	10420 <printf@plt>
  scanf("%d", & input);
   10aec:	e24b3010 	sub	r3, fp, #16
   10af0:	e1a01003 	mov	r1, r3
   10af4:	e59f00cc 	ldr	r0, [pc, #204]	; 10bc8 <main+0x15c>
   10af8:	ebfffe5a 	bl	10468 <scanf@plt>
  count = location(head, input);
   10afc:	e51b3010 	ldr	r3, [fp, #-16]
   10b00:	e1a01003 	mov	r1, r3
   10b04:	e51b0008 	ldr	r0, [fp, #-8]
   10b08:	ebffff49 	bl	10834 <location>
   10b0c:	e1a03000 	mov	r3, r0
   10b10:	e50b3014 	str	r3, [fp, #-20]	; 0xffffffec
  printf("The value's  position is : %d\n", count);
   10b14:	e51b3014 	ldr	r3, [fp, #-20]	; 0xffffffec
   10b18:	e1a01003 	mov	r1, r3
   10b1c:	e59f00ac 	ldr	r0, [pc, #172]	; 10bd0 <main+0x164>
   10b20:	ebfffe3e 	bl	10420 <printf@plt>

  printf("input insert value and position:");
   10b24:	e59f00a8 	ldr	r0, [pc, #168]	; 10bd4 <main+0x168>
   10b28:	ebfffe3c 	bl	10420 <printf@plt>
  scanf("%d %d", & count, & input);
   10b2c:	e24b2010 	sub	r2, fp, #16
   10b30:	e24b3014 	sub	r3, fp, #20
   10b34:	e1a01003 	mov	r1, r3
   10b38:	e59f0098 	ldr	r0, [pc, #152]	; 10bd8 <main+0x16c>
   10b3c:	ebfffe49 	bl	10468 <scanf@plt>
  head = insert(head, count, input);
   10b40:	e51b3014 	ldr	r3, [fp, #-20]	; 0xffffffec
   10b44:	e51b2010 	ldr	r2, [fp, #-16]
   10b48:	e1a01003 	mov	r1, r3
   10b4c:	e51b0008 	ldr	r0, [fp, #-8]
   10b50:	ebffff5d 	bl	108cc <insert>
   10b54:	e50b0008 	str	r0, [fp, #-8]
  display(head);
   10b58:	e51b0008 	ldr	r0, [fp, #-8]
   10b5c:	ebfffedd 	bl	106d8 <display>

  printf("input delete position:");
   10b60:	e59f0074 	ldr	r0, [pc, #116]	; 10bdc <main+0x170>
   10b64:	ebfffe2d 	bl	10420 <printf@plt>
  scanf("%d", & input);
   10b68:	e24b3010 	sub	r3, fp, #16
   10b6c:	e1a01003 	mov	r1, r3
   10b70:	e59f0050 	ldr	r0, [pc, #80]	; 10bc8 <main+0x15c>
   10b74:	ebfffe3b 	bl	10468 <scanf@plt>
  head = delete(head, input);
   10b78:	e51b3010 	ldr	r3, [fp, #-16]
   10b7c:	e1a01003 	mov	r1, r3
   10b80:	e51b0008 	ldr	r0, [fp, #-8]
   10b84:	ebffff7d 	bl	10980 <delete>
   10b88:	e50b0008 	str	r0, [fp, #-8]
  display(head);
   10b8c:	e51b0008 	ldr	r0, [fp, #-8]
   10b90:	ebfffed0 	bl	106d8 <display>

  count = length(head);
   10b94:	e51b0008 	ldr	r0, [fp, #-8]
   10b98:	ebffff9a 	bl	10a08 <length>
   10b9c:	e1a03000 	mov	r3, r0
   10ba0:	e50b3014 	str	r3, [fp, #-20]	; 0xffffffec
  printf("take head node of double list of length is : %d\n", count);
   10ba4:	e51b3014 	ldr	r3, [fp, #-20]	; 0xffffffec
   10ba8:	e1a01003 	mov	r1, r3
   10bac:	e59f002c 	ldr	r0, [pc, #44]	; 10be0 <main+0x174>
   10bb0:	ebfffe1a 	bl	10420 <printf@plt>
}
   10bb4:	e1a00003 	mov	r0, r3
   10bb8:	e24bd004 	sub	sp, fp, #4
   10bbc:	e8bd8800 	pop	{fp, pc}
   10bc0:	00010c58 	.word	0x00010c58
   10bc4:	00010c74 	.word	0x00010c74
   10bc8:	00010c08 	.word	0x00010c08
   10bcc:	00010c88 	.word	0x00010c88
   10bd0:	00010ca8 	.word	0x00010ca8
   10bd4:	00010cc8 	.word	0x00010cc8
   10bd8:	00010cec 	.word	0x00010cec
   10bdc:	00010cf4 	.word	0x00010cf4
   10be0:	00010d0c 	.word	0x00010d0c

Disassembly of section .fini:

00010be4 <_fini>:
   10be4:	e1a0c00d 	mov	ip, sp
   10be8:	e92ddff0 	push	{r4, r5, r6, r7, r8, r9, sl, fp, ip, lr, pc}
   10bec:	e24cb004 	sub	fp, ip, #4
   10bf0:	e91baff0 	ldmdb	fp, {r4, r5, r6, r7, r8, r9, sl, fp, sp, pc}
